package com.ts.api.http.receive.biz;

import com.gitee.apanlh.util.algorithm.encrypt.symmetric.AES;
import com.gitee.apanlh.util.base.ChooseEq;
import com.gitee.apanlh.util.base.MapUtils;
import com.gitee.apanlh.util.dataformat.JsonUtils;
import com.gitee.apanlh.util.reflection.CopyUtils;
import com.gitee.apanlh.util.valid.Assert;
import com.gitee.apanlh.util.valid.ValidParam;
import com.gitee.apanlh.web.model.vo.RequestVO;
import com.ts.api.common.constant.api.ApiEnum;
import com.ts.api.common.util.ApiDictUtils;
import com.ts.api.exp.ApiMsgException;
import com.ts.api.http.receive.entity.apply.req.ApiReceiveApplyLingQianMao;
import com.ts.api.http.receive.entity.dataexchange.req.ApiReceiveDataExchangeMaskLingQianMao;
import com.ts.api.module.api.convert.core.annotation.ApiReceive;
import com.ts.api.module.api.convert.core.annotation.ApiReceiveConvertType;
import com.ts.api.module.api.convert.receive.entity.ApiReceiveApply;
import com.ts.api.module.api.convert.receive.entity.ApiReceiveDecrypt;
import com.ts.api.module.api.convert.receive.entity.ApiReceiveNotice;
import com.ts.api.module.api.convert.receive.entity.ApiReceivePhoneMaskDataExchange;
import com.ts.api.module.api.convert.receive.handler.ApiReceivePhoneMaskConvertHandler;
import com.ts.api.module.api.entity.ApiUserRequest;
import com.ts.api.module.match.plan.internal.distribute.model.PlanDistributePhoneMaskField;

import java.util.List;
import java.util.Map;

/**
 * 零钱猫（出）&安心分期 全28 8位
 *
 * @author WJB
 */
@ApiReceive(apiClientId = "1980337274956435456", type = ApiReceiveConvertType.API_CHANNEL_PHONE_MASK)
public class ApiReceiveMaskLingQianMao implements ApiReceivePhoneMaskConvertHandler {

    public static final String KEY = "7XyZ1V7J4nLk9PqR2sT3Uw==";

    @Override
    public Map<String, String> requireParam(RequestVO requestVO) throws Exception {
        //  获取请求体参数
        Map<String, Object> map = JsonUtils.toMap(requestVO.getBody());
        String data = String.valueOf(map.get("data"));

        Assert.isNotEmptyThrows(data, new ApiMsgException(ApiEnum.API_RECEIVE_BODY_MISS.format("data")));

        //  返回需要的数据Map
        return MapUtils.newHashMap(newMap -> {
            newMap.put("data", data);
        });
    }

    @Override
    public ApiReceiveDecrypt decrypt(Map<String, String> paramMap, RequestVO requestVO) throws Exception {
        String params = paramMap.get("data");

        //  文档解密过程
        AES cbc = AES.createEcb(KEY.getBytes());
        String decrypt = cbc.decryptFromBase64Str(params);
        return new ApiReceiveDecrypt(decrypt);
    }

    @Override
    public ApiUserRequest parseDataExchange(ApiReceiveDecrypt apiReceiveDecryptMessage) throws Exception {
        ApiReceiveDataExchangeMaskLingQianMao parse = apiReceiveDecryptMessage.parse(ApiReceiveDataExchangeMaskLingQianMao.class);
        ApiUserRequest apiUserRequest = CopyUtils.copy(parse, ApiUserRequest.class);
        fieldMapping(apiUserRequest);
        return apiUserRequest;
    }

    @Override
    public Map<String, Object> respDataExchange(ApiReceivePhoneMaskDataExchange dataExchangeMessage) throws Exception {
        List<PlanDistributePhoneMaskField> listPhoneMaskField = dataExchangeMessage.getListPhoneMaskField();
        boolean suc = dataExchangeMessage.hasBizSuc();
        if (!suc) {
            Map<String, Object> resultMap = MapUtils.newLinkedHashMap();
            resultMap.put("code", 500);
            resultMap.put("msg", dataExchangeMessage.getBizMsg());
            return resultMap;
        }

        Map<String, Object> resultMap = MapUtils.newLinkedHashMap();
        resultMap.put("code", 0);
        resultMap.put("msg", "SUCCESS");

        //  假设只处理第一个元素（根据业务需求调整）
        PlanDistributePhoneMaskField field = listPhoneMaskField.getFirst();
        // 构建数据对象
        resultMap.put("data", MapUtils.newLinkedHashMap(dataObj -> {
            dataObj.put("price", field.getPrice());
            dataObj.put("resId", field.getApplyId());
            dataObj.put("md5List", field.getListPhoneMd5());
        }));

        return resultMap;
    }

    @Override
    public ApiUserRequest parseApply(ApiReceiveDecrypt apiReceiveDecryptMessage) throws Exception {
        ApiReceiveApplyLingQianMao parse = apiReceiveDecryptMessage.parse(ApiReceiveApplyLingQianMao.class);
        ApiUserRequest apiUserRequest = CopyUtils.copy(parse, ApiUserRequest.class);
        fieldMapping(apiUserRequest);
        //  进件返序列化订单号
        return apiUserRequest;
    }

    @Override
    public Map<String, Object> respApply(ApiReceiveApply applyMessage) throws Exception {
        boolean suc = applyMessage.hasBizSuc();

        // 失败
        if (!suc) {
            Map<String, Object> resultMap = MapUtils.newLinkedHashMap();
            resultMap.put("code", 500);
            resultMap.put("msg", applyMessage.getBizMsg());
            return resultMap;
        }

        // 成功
        Map<String, Object> resultMap = MapUtils.newLinkedHashMap();
        resultMap.put("code", 0);
        resultMap.put("msg", "SUCCESS");
        return resultMap;
    }

    @Override
    public void fieldMapping(ApiUserRequest apiUserRequest) {
        //  年龄(21岁-55岁)
        String age1 = apiUserRequest.getAge();
        if (ValidParam.isNotEmpty(age1)) {
            String age = ApiDictUtils.convertAge(apiUserRequest.getAge());
            apiUserRequest.setAge(age);
        }

        //  gender 性别：1-男、2-女
        //  sex 性别
        //  0 男
        //  1 女
        //  2 未知
        String sex = apiUserRequest.getSex();
        {
            String sexChoose = ChooseEq.create()
                    .when(sex, "1", "0")
                    .when(sex, "2", "1")
                    .end("2");
            apiUserRequest.setSex(sexChoose);
        }

        // job 职业 0、上班族 1、私营企业 2、事业单位 3、个体户 4、农.林.牧.渔水利生产人员 5、 自由职业
        // career
        //   1	上班族
        //   2	自由职业
        //   3	企业主（有营业执照）
        //   4	公务员或事业单位
        //   5	个体户
        String career = apiUserRequest.getCareer();
        if (ValidParam.isNotEmpty(career)) {
            String value = ChooseEq.create()
                    .when(career, "0", "1")
                    .when(career, "1", "3")
                    .when(career, "2", "4")
                    .when(career, "3", "5")
                    .when(career, "4", "1")
                    .when(career, "5", "2")
                    .end();
            apiUserRequest.setCareer(value);
        }

        // loanTime 申请借款期限(月份)
        //  贷款期限
        //  1.3个月
        //  2.6个月
        //  3.12个月
        //  4.24个月
        //  5.36个月
        //  6.60个月
        String loanTerm = apiUserRequest.getLoanTerm();
        if (ValidParam.isNotEmpty(loanTerm)) {
            String value = ApiDictUtils.convertLoanTerm(loanTerm);
            apiUserRequest.setLoanTerm(value);
        }

        // aliPay  芝麻分 1、(600-650分) 2、(650-700分) 3、( 700分以上
        // sesameCredit 芝麻分
        // 1 600分以下
        // 2 600~649分
        // 3 650~699分
        // 4 700分以上
        String sesameCredit = apiUserRequest.getSesameCredit();
        if (ValidParam.isNotEmpty(sesameCredit)) {
            String value = ChooseEq.create()
                    .when(sesameCredit, "1", "2")
                    .when(sesameCredit, "2", "3")
                    .when(sesameCredit, "3", "4")
                    .end();
            apiUserRequest.setSesameCredit(value);
        }

        // publicFund 公积金缴纳 0、未缴纳 1、未满6个月 2、6个月以上
        // providentFund 公积金
        // 1 无公积金
        // 2 缴纳6个月以下
        // 3 缴纳6个月以上
        // 4 有公积金
        String providentFund = apiUserRequest.getProvidentFund();
        if (ValidParam.isNotEmpty(providentFund)) {
            String value = ChooseEq.create()
                    .when(providentFund, "0", "1")
                    .when(providentFund, "1", "2")
                    .when(providentFund, "2", "3")
                    .end();
            apiUserRequest.setProvidentFund(value);
        }

        // socialSecurity 社保：0-无社保、1-六个月以下、2、六个月以上
        // socialSecurity 社保缴纳
        // 1 无社保
        // 2 缴纳6个月以下
        // 3 缴纳6个月以上
        // 4 有社保
        String socialSecurity = apiUserRequest.getSocialSecurity();
        if (ValidParam.isNotEmpty(socialSecurity)) {
            String value = ChooseEq.create()
                    .when(socialSecurity, "0", "1")
                    .when(socialSecurity, "1", "2")
                    .when(socialSecurity, "2", "3")
                    .end();
            apiUserRequest.setSocialSecurity(value);
        }

        // haveHouse 本人名下是否有房 0、无房产 1、 有房，可抵押 2 、有房，不抵押
        // realEstateInfo 房产情况
        // 1 无房产
        // 2 有房不抵押
        // 3 有房可抵押
        // 4 有房产
        // 5 有按揭房产
        // 6 有全款房产
        String realEstateInfo = apiUserRequest.getRealEstateInfo();
        if (ValidParam.isNotEmpty(realEstateInfo)) {
            String value = ChooseEq.create()
                    .when(realEstateInfo, "0", "1")
                    .when(realEstateInfo, "1", "3")
                    .when(realEstateInfo, "2", "2")
                    .end();
            apiUserRequest.setRealEstateInfo(value);
        }

        // trustInfo 信用情况 0、信用良好无逾期 3 、信用卡或贷款当前存在逾期
        // overdue 逾期
        // 1 无逾期
        // 2 当前有逾期
        // 3 一年以内无逾期
        String overdue = apiUserRequest.getOverdue();
        if (ValidParam.isNotEmpty(overdue)) {
            String value = ChooseEq.create()
                    .when(overdue, "0", "1")
                    .when(overdue, "3", "2")
                    .end();
            apiUserRequest.setOverdue(value);
        }

        // insurance 保险情况 0、未购保险 1 、缴纳未满1年 2、 缴纳1年以上
        // insurancePolicy 保险保单
        // 1 无保险保单
        // 2 缴纳未满1年
        // 3 缴纳1年以上
        // 4 有保险保单
        String insurancePolicy = apiUserRequest.getInsurancePolicy();
        if (ValidParam.isNotEmpty(insurancePolicy)) {
            String value = ChooseEq.create()
                    .when(insurancePolicy, "0", "1")
                    .when(insurancePolicy, "1", "2")
                    .when(insurancePolicy, "2", "3")
                    .end();
            apiUserRequest.setInsurancePolicy(value);
        }

        // carProperty 本人名下是否有车 0、无车辆 1、有车
        // carInfo 车辆情况
        // 1 无车产
        // 2 有车不抵押
        // 3 有车可抵押
        // 4 有车产
        String carInfo = apiUserRequest.getCarInfo();
        if (ValidParam.isNotEmpty(carInfo)) {
            String value = ChooseEq.create()
                    .when(carInfo, "0", "1")
                    .when(carInfo, "1", "4")
                    .end();
            apiUserRequest.setCarInfo(value);
        }

        // applyLimit  贷款金额需 1-0万 ~3万、2-3万 ~5万、3-5万 ~10万、4-10万 ~20万
        // loanAmount 贷款金额
        // 1 3万以下
        // 2 5万-10万
        // 3 10万-20万
        // 4 20万以上
        String loanAmount = apiUserRequest.getLoanAmount();
        if (ValidParam.isNotEmpty(loanAmount)) {
            String value = ApiDictUtils.convertLoanAmount(loanAmount, true);
            apiUserRequest.setLoanAmount(value);
        }

        // applyPurpose 借款用途 0、个人/家庭消费 1、教育培训 2、 进货 3、购买家具或家电 4、装修 5、婚庆 6、健康医疗
        // loanPurpose 借款用途
        // 1 旅游
        // 2 教育
        // 3 婚庆
        // 4 装修
        // 5 医疗
        // 6 个人消费
        String loanPurpose = apiUserRequest.getLoanPurpose();
        if (ValidParam.isNotEmpty(loanPurpose)) {
            String value = ChooseEq.create()
                    .when(loanPurpose, "0", "6")
                    .when(loanPurpose, "1", "2")
                    .when(loanPurpose, "2", "6")
                    .when(loanPurpose, "3", "4")
                    .when(loanPurpose, "4", "4")
                    .when(loanPurpose, "5", "3")
                    .when(loanPurpose, "6", "5")
                    .end();
            apiUserRequest.setLoanPurpose(value);
        }

        //  学历 0、研究生及以上 1、大学本科 2、大学专科 3、高中或中专4、初中及以下
        //  学历
        //  1.初中及以下
        //  2.中专
        //  3.高中
        //  4.大专
        //  5.本科
        //  6.研究生及以上
        String educationAttainment = apiUserRequest.getEducationAttainment();
        if (ValidParam.isNotEmpty(educationAttainment)) {
            String value = ChooseEq.create()
                    .when(educationAttainment, "0", "6")
                    .when(educationAttainment, "1", "5")
                    .when(educationAttainment, "2", "4")
                    .when(educationAttainment, "3", "3")
                    .when(educationAttainment, "4", "1")
                    .end();
            apiUserRequest.setEducationAttainment(value);
        }

        // 月收入 0、3000及以下 1、3000-6000 2、 6000-9000 3、 9000-12000 4、 12000-15000 5、15000以上
        // 1 1000-3000
        // 2 3000-8000
        // 3 8000-15000
        // 4 15000-30000
        // 5 30000以上
        String monthlySalary = apiUserRequest.getMonthlySalary();
        if (ValidParam.isNotEmpty(monthlySalary)) {
            String value = ChooseEq.create()
                    .when(monthlySalary, "0", "1")
                    .when(monthlySalary, "1", "2")
                    .when(monthlySalary, "2", "2")
                    .when(monthlySalary, "3", "3")
                    .when(monthlySalary, "4", "3")
                    .when(monthlySalary, "5", "4")
                    .end();
            apiUserRequest.setMonthlySalary(value);
        }

        // workAge 单位工龄 0、0-6个月 1、6-12个月 2、 1-3年 3、 3年以上
        // 1 0-6个月
        // 2 6-12个月
        // 3 12个月以上
        String yearsService = apiUserRequest.getYearsService();
        if (ValidParam.isNotEmpty(yearsService)) {
            String value = ChooseEq.create()
                    .when(yearsService, "0", "1")
                    .when(yearsService, "1", "2")
                    .when(yearsService, "2", "3")
                    .when(yearsService, "3", "3")
                    .end();
            apiUserRequest.setYearsService(value);
        }

        // creditCard 信用卡额度 0、 无信用卡 1、1万以下 2、 1-3万 3、 3万以上
        // creditLimit 信用卡额度
        // 1 无信用卡
        // 2 3千以下
        // 3 3千-1万
        // 4 1-3万
        // 5 3万以上
        // 6 有信用卡
        String creditLimit = apiUserRequest.getCreditLimit();
        if (ValidParam.isNotEmpty(creditLimit)) {
            String value = ChooseEq.create()
                    .when(creditLimit, "0", "1")
                    .when(creditLimit, "1", "3")
                    .when(creditLimit, "2", "4")
                    .when(creditLimit, "3", "5")
                    .end();
            apiUserRequest.setCreditLimit(value);
        }
        // 营业执照 0、未注册 1、注册1年以下 2、注册1-5年 3、注册5年以上 （当job为1或3时存在
        // 营业执照注册年限
        // 1 未注册
        // 2 注册1年以下
        // 3 注册1~5年
        // 4 注册5年以上
        if (ValidParam.isNotEmpty(apiUserRequest.getBizLicenseYear())) {
            String value = ChooseEq.create()
                    .when(apiUserRequest.getBizLicenseYear(), "0", "1")
                    .when(apiUserRequest.getBizLicenseYear(), "1", "2")
                    .when(apiUserRequest.getBizLicenseYear(), "2", "3")
                    .when(apiUserRequest.getBizLicenseYear(), "3", "4")
                    .end();
            apiUserRequest.setBizLicenseYear(value);
        }
    }

    @Override
    public Object reqPullApplyNotice(ApiReceiveNotice apiNoticeMessage) {
        return null;
    }

    @Override
    public boolean respPullApplyNotice(String responseBody) {
        return false;
    }

    @Override
    public Object reqPushApplyNotice(ApiReceiveNotice apiNoticeMessage) {
        return null;
    }

    @Override
    public boolean respPushApplyNotice(String responseBody) {
        return false;
    }
}
